home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / lib / gcc-lib / ppc-amigaos / 2.95.1 / sys-include / powerup / ppcpragmas / mathieeedoubbas_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-03-13  |  7KB  |  250 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_MATHIEEEDOUBBAS_H
  4. #define _PPCPRAGMA_MATHIEEEDOUBBAS_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__MATHIEEEDOUBBAS_H
  7. #include <powerup/ppcinline/mathieeedoubbas.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef MATHIEEEDOUBBAS_BASE_NAME
  24. #define MATHIEEEDOUBBAS_BASE_NAME MathIeeeDoubBasBase
  25. #endif /* !MATHIEEEDOUBBAS_BASE_NAME */
  26.  
  27. #define    IEEEDPAbs(parm)    _IEEEDPAbs(MATHIEEEDOUBBAS_BASE_NAME, parm)
  28.  
  29. static __inline DOUBLE
  30. _IEEEDPAbs(void *MathIeeeDoubBasBase, DOUBLE parm)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.d0        =(ULONG) parm;
  40.     MyCaos.caos_Un.Offset    =    (-54);
  41.     MyCaos.a6        =(ULONG) MathIeeeDoubBasBase;    
  42.     return((DOUBLE)PPCCallOS(&MyCaos));
  43. }
  44.  
  45. #define    IEEEDPAdd(leftParm, rightParm)    _IEEEDPAdd(MATHIEEEDOUBBAS_BASE_NAME, leftParm, rightParm)
  46.  
  47. static __inline DOUBLE
  48. _IEEEDPAdd(void *MathIeeeDoubBasBase, DOUBLE leftParm, DOUBLE rightParm)
  49. {
  50. struct Caos    MyCaos;
  51.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  52. //    MyCaos.M68kStart    =    NULL;
  53. //    MyCaos.M68kSize        =    0;
  54.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  55. //    MyCaos.PPCStart        =    NULL;
  56. //    MyCaos.PPCSize        =    0;
  57.     MyCaos.d0        =(ULONG) leftParm;
  58.     MyCaos.d2        =(ULONG) rightParm;
  59.     MyCaos.caos_Un.Offset    =    (-66);
  60.     MyCaos.a6        =(ULONG) MathIeeeDoubBasBase;    
  61.     return((DOUBLE)PPCCallOS(&MyCaos));
  62. }
  63.  
  64. #define    IEEEDPCeil(parm)    _IEEEDPCeil(MATHIEEEDOUBBAS_BASE_NAME, parm)
  65.  
  66. static __inline DOUBLE
  67. _IEEEDPCeil(void *MathIeeeDoubBasBase, DOUBLE parm)
  68. {
  69. struct Caos    MyCaos;
  70.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  71. //    MyCaos.M68kStart    =    NULL;
  72. //    MyCaos.M68kSize        =    0;
  73.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  74. //    MyCaos.PPCStart        =    NULL;
  75. //    MyCaos.PPCSize        =    0;
  76.     MyCaos.d0        =(ULONG) parm;
  77.     MyCaos.caos_Un.Offset    =    (-96);
  78.     MyCaos.a6        =(ULONG) MathIeeeDoubBasBase;    
  79.     return((DOUBLE)PPCCallOS(&MyCaos));
  80. }
  81.  
  82. #define    IEEEDPCmp(leftParm, rightParm)    _IEEEDPCmp(MATHIEEEDOUBBAS_BASE_NAME, leftParm, rightParm)
  83.  
  84. static __inline LONG
  85. _IEEEDPCmp(void *MathIeeeDoubBasBase, DOUBLE leftParm, DOUBLE rightParm)
  86. {
  87. struct Caos    MyCaos;
  88.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  89. //    MyCaos.M68kStart    =    NULL;
  90. //    MyCaos.M68kSize        =    0;
  91.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  92. //    MyCaos.PPCStart        =    NULL;
  93. //    MyCaos.PPCSize        =    0;
  94.     MyCaos.d0        =(ULONG) leftParm;
  95.     MyCaos.d2        =(ULONG) rightParm;
  96.     MyCaos.caos_Un.Offset    =    (-42);
  97.     MyCaos.a6        =(ULONG) MathIeeeDoubBasBase;    
  98.     return((LONG)PPCCallOS(&MyCaos));
  99. }
  100.  
  101. #define    IEEEDPDiv(dividend, divisor)    _IEEEDPDiv(MATHIEEEDOUBBAS_BASE_NAME, dividend, divisor)
  102.  
  103. static __inline DOUBLE
  104. _IEEEDPDiv(void *MathIeeeDoubBasBase, DOUBLE dividend, DOUBLE divisor)
  105. {
  106. struct Caos    MyCaos;
  107.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  108. //    MyCaos.M68kStart    =    NULL;
  109. //    MyCaos.M68kSize        =    0;
  110.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  111. //    MyCaos.PPCStart        =    NULL;
  112. //    MyCaos.PPCSize        =    0;
  113.     MyCaos.d0        =(ULONG) dividend;
  114.     MyCaos.d2        =(ULONG) divisor;
  115.     MyCaos.caos_Un.Offset    =    (-84);
  116.     MyCaos.a6        =(ULONG) MathIeeeDoubBasBase;    
  117.     return((DOUBLE)PPCCallOS(&MyCaos));
  118. }
  119.  
  120. #define    IEEEDPFix(parm)    _IEEEDPFix(MATHIEEEDOUBBAS_BASE_NAME, parm)
  121.  
  122. static __inline LONG
  123. _IEEEDPFix(void *MathIeeeDoubBasBase, DOUBLE parm)
  124. {
  125. struct Caos    MyCaos;
  126.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  127. //    MyCaos.M68kStart    =    NULL;
  128. //    MyCaos.M68kSize        =    0;
  129.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  130. //    MyCaos.PPCStart        =    NULL;
  131. //    MyCaos.PPCSize        =    0;
  132.     MyCaos.d0        =(ULONG) parm;
  133.     MyCaos.caos_Un.Offset    =    (-30);
  134.     MyCaos.a6        =(ULONG) MathIeeeDoubBasBase;    
  135.     return((LONG)PPCCallOS(&MyCaos));
  136. }
  137.  
  138. #define    IEEEDPFloor(parm)    _IEEEDPFloor(MATHIEEEDOUBBAS_BASE_NAME, parm)
  139.  
  140. static __inline DOUBLE
  141. _IEEEDPFloor(void *MathIeeeDoubBasBase, DOUBLE parm)
  142. {
  143. struct Caos    MyCaos;
  144.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  145. //    MyCaos.M68kStart    =    NULL;
  146. //    MyCaos.M68kSize        =    0;
  147.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  148. //    MyCaos.PPCStart        =    NULL;
  149. //    MyCaos.PPCSize        =    0;
  150.     MyCaos.d0        =(ULONG) parm;
  151.     MyCaos.caos_Un.Offset    =    (-90);
  152.     MyCaos.a6        =(ULONG) MathIeeeDoubBasBase;    
  153.     return((DOUBLE)PPCCallOS(&MyCaos));
  154. }
  155.  
  156. #define    IEEEDPFlt(integer)    _IEEEDPFlt(MATHIEEEDOUBBAS_BASE_NAME, integer)
  157.  
  158. static __inline DOUBLE
  159. _IEEEDPFlt(void *MathIeeeDoubBasBase, long integer)
  160. {
  161. struct Caos    MyCaos;
  162.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  163. //    MyCaos.M68kStart    =    NULL;
  164. //    MyCaos.M68kSize        =    0;
  165.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  166. //    MyCaos.PPCStart        =    NULL;
  167. //    MyCaos.PPCSize        =    0;
  168.     MyCaos.d0        =(ULONG) integer;
  169.     MyCaos.caos_Un.Offset    =    (-36);
  170.     MyCaos.a6        =(ULONG) MathIeeeDoubBasBase;    
  171.     return((DOUBLE)PPCCallOS(&MyCaos));
  172. }
  173.  
  174. #define    IEEEDPMul(factor1, factor2)    _IEEEDPMul(MATHIEEEDOUBBAS_BASE_NAME, factor1, factor2)
  175.  
  176. static __inline DOUBLE
  177. _IEEEDPMul(void *MathIeeeDoubBasBase, DOUBLE factor1, DOUBLE factor2)
  178. {
  179. struct Caos    MyCaos;
  180.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  181. //    MyCaos.M68kStart    =    NULL;
  182. //    MyCaos.M68kSize        =    0;
  183.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  184. //    MyCaos.PPCStart        =    NULL;
  185. //    MyCaos.PPCSize        =    0;
  186.     MyCaos.d0        =(ULONG) factor1;
  187.     MyCaos.d2        =(ULONG) factor2;
  188.     MyCaos.caos_Un.Offset    =    (-78);
  189.     MyCaos.a6        =(ULONG) MathIeeeDoubBasBase;    
  190.     return((DOUBLE)PPCCallOS(&MyCaos));
  191. }
  192.  
  193. #define    IEEEDPNeg(parm)    _IEEEDPNeg(MATHIEEEDOUBBAS_BASE_NAME, parm)
  194.  
  195. static __inline DOUBLE
  196. _IEEEDPNeg(void *MathIeeeDoubBasBase, DOUBLE parm)
  197. {
  198. struct Caos    MyCaos;
  199.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  200. //    MyCaos.M68kStart    =    NULL;
  201. //    MyCaos.M68kSize        =    0;
  202.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  203. //    MyCaos.PPCStart        =    NULL;
  204. //    MyCaos.PPCSize        =    0;
  205.     MyCaos.d0        =(ULONG) parm;
  206.     MyCaos.caos_Un.Offset    =    (-60);
  207.     MyCaos.a6        =(ULONG) MathIeeeDoubBasBase;    
  208.     return((DOUBLE)PPCCallOS(&MyCaos));
  209. }
  210.  
  211. #define    IEEEDPSub(leftParm, rightParm)    _IEEEDPSub(MATHIEEEDOUBBAS_BASE_NAME, leftParm, rightParm)
  212.  
  213. static __inline DOUBLE
  214. _IEEEDPSub(void *MathIeeeDoubBasBase, DOUBLE leftParm, DOUBLE rightParm)
  215. {
  216. struct Caos    MyCaos;
  217.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  218. //    MyCaos.M68kStart    =    NULL;
  219. //    MyCaos.M68kSize        =    0;
  220.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  221. //    MyCaos.PPCStart        =    NULL;
  222. //    MyCaos.PPCSize        =    0;
  223.     MyCaos.d0        =(ULONG) leftParm;
  224.     MyCaos.d2        =(ULONG) rightParm;
  225.     MyCaos.caos_Un.Offset    =    (-72);
  226.     MyCaos.a6        =(ULONG) MathIeeeDoubBasBase;    
  227.     return((DOUBLE)PPCCallOS(&MyCaos));
  228. }
  229.  
  230. #define    IEEEDPTst(parm)    _IEEEDPTst(MATHIEEEDOUBBAS_BASE_NAME, parm)
  231.  
  232. static __inline LONG
  233. _IEEEDPTst(void *MathIeeeDoubBasBase, DOUBLE parm)
  234. {
  235. struct Caos    MyCaos;
  236.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  237. //    MyCaos.M68kStart    =    NULL;
  238. //    MyCaos.M68kSize        =    0;
  239.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  240. //    MyCaos.PPCStart        =    NULL;
  241. //    MyCaos.PPCSize        =    0;
  242.     MyCaos.d0        =(ULONG) parm;
  243.     MyCaos.caos_Un.Offset    =    (-48);
  244.     MyCaos.a6        =(ULONG) MathIeeeDoubBasBase;    
  245.     return((LONG)PPCCallOS(&MyCaos));
  246. }
  247.  
  248. #endif /* SASC Pragmas */
  249. #endif /* !_PPCPRAGMA_MATHIEEEDOUBBAS_H */
  250.